
//-----------------------------------------------------------------------------------------------
//2007-9-2 17:35

//rf_hosp_rdcard			//读卡信息
//rf_hosp_trade				//交易
//-----------------------------------------------------------------------------------------------
/*

  函数错误代码
  返回值(负数)    错误类型
  0x80(128)       读错误
  0x81(129)       写错误
  0x82(130)       通讯错误
  0x84(132)       超时错误
  0x87(135)       格式错误
*/



#include "utiledef.h"
#include "serialportapi.h"

DLLexport int WINAPI rf_exit(HANDLE icdev);

static  int commport_flag=0x0;





#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


//关闭RFID
int  rf_PowerRFIDOff()
{
#if WINCE
	int returnValue=false;


	HINSTANCE hDllInst = LoadLibrary(_T("DeviceAPI.dll"));
	if(hDllInst)
	{
		typedef DWORD (WINAPI *MYFUNC)();//(DWORD,DWORD);
		MYFUNC PowerRFIDOff = (MYFUNC)GetProcAddress(hDllInst,_T("rfid_poweroff"));
		if(PowerRFIDOff)
		{
			returnValue=PowerRFIDOff();//(NULL,NULL);
		}
		FreeLibrary(hDllInst);
	}
	return returnValue;
#else
	return 1;
#endif


}

//开启RFID
int  rf_PowerRFIDON()
{

#if WINCE
	int returnValue=false;


	HINSTANCE hDllInst = LoadLibrary(_T("DeviceAPI.dll"));
	if(hDllInst)
	{
		typedef DWORD (WINAPI *MYFUNC)();//(DWORD,DWORD);
		MYFUNC PowerRFIDOn = (MYFUNC)GetProcAddress(hDllInst,_T("rfid_poweron"));
		if(PowerRFIDOn)
		{
			returnValue=PowerRFIDOn();//(NULL,NULL);
		}
		FreeLibrary(hDllInst);
	}
	Sleep(500);
	return returnValue;
#else
	return 1;
#endif
	


}

int chtohe(char as)
{
    if((as>='0') && (as<='9'))  return (as-48);
	if((as>='a') && (as<='f'))  return (as-87);
	if((as>='A') && (as<='F'))  return (as-55);
	return -1;
}

int chtoascc(char data_a)
{
    if((data_a>='0') && (data_a<='9'))  
	{
		chtohe(data_a);
		return (chtohe(data_a)+48);
    }
    if((data_a>='a') && (data_a<='f'))  
	{
		chtohe(data_a);
		return (chtohe(data_a)+55);
    }
    if((data_a>='A') && (data_a<='F')) 
	{
		chtohe(data_a);
		return (chtohe(data_a)+55);
    }
    return -1;
}

int  shake(HANDLE icdev);


//打开通信接口,成功则返回该串口的句柄-------------------------------------



//串口初始化,设置超时,并与读写器进行握手,握手成功则返回
//该串口的句柄,否则,关闭该串口

DLLexport HANDLE WINAPI rf_init(int icdev,long baud)
{
   HANDLE h_dev;
   rf_PowerRFIDON();
  // icdev=0xff;

   	if(icdev==0xff)
   	{	
#if (WINCE)

#elif (WIN32)
		commport_flag=1;
   		h_dev=CUSBDevice_Connect();
		if(h_dev ==INVALID_HANDLE_VALUE)
		{
			return (HANDLE) -130;//通讯错误
		}
#else
		return (HANDLE) -131;
#endif


	}
	else
	{	
		commport_flag=0;
		h_dev=OpenComm(icdev,baud);
		if(h_dev < 0)
		{
		 	return (HANDLE) -132;//通讯错误
		}
	}		
// 	while(1)
//    {
//        shake(h_dev);
//    }
#if COM_DEBUG
	LOGD("shake ");
#endif
	if(shake(h_dev)!=0) 
	{
#if COM_DEBUG
		LOGD("shake ERROR ");
#endif
		   rf_exit(h_dev);

#if COM_DEBUG
		LOGD("shake EXIT  ");
#endif
		return h_dev; // 握手失败也返回成功。原来的库有bug.
		//   return (HANDLE) -133;//通讯错误
	}

#if COM_DEBUG
	LOGD("shake ok");
#endif
    return h_dev;
}








int  SendData_N(HANDLE icdev,int len,uchar *sendbuf)
{
	if(commport_flag==1)
	{

#ifdef WIN32
		return 	USB_WriteChar_N(icdev,len,sendbuf);
#else
		return 1;
#endif

	}
	else
	{
		return 	WriteChar_N(icdev,len,sendbuf);
	}
	
	return 1;
}


int RecData_N(HANDLE icdev,uchar *rlen,uchar *rebuf)
{
	if(commport_flag==1)
	{

#ifdef WIN32
	return USB_ReadChar_N(icdev,rlen,rebuf);
#else
	return 1;
#endif
	}
	else
	{
		return ReadChar_N(icdev,rlen,rebuf);
	}

	return 1;
	
}




//关闭通信接口-------------------------------------
 DLLexport int WINAPI rf_exit(HANDLE icdev)
{
#if WIN32
	rf_PowerRFIDOff();
	CloseHandle(icdev);
#else
	CloseComm(icdev);
#endif

	return 0;
}


// 调用格式：A7 03 13 30 30 XOR   
// A7：起始符
// 03：数据长度
// 13：握手命令
// 30：握手时传送的信息
// XOR：从起始符开始到DATA的最后一个字节为止的异或校验值

int shake(HANDLE icdev)
{
    int i;
	uchar t=0,rt=0;
	uchar LRC=0;
	uchar len=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	int j;
	for(j=0;j<40;j++)
	{
		rebuf[j]=' ';
	}
    PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);

	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x13;   //命令字
	sendbuf[3]=0x30;   //握手时传送的信息,发两次
    sendbuf[4]=0x30;
	sendbuf[5]=0;

// 求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[5]=sendbuf[5]^sendbuf[i];
      
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }	

	return 0;

}

// 寻卡
// 调用格式：A7 02 01 MODE XOR 
// A7：起始符
// 02：数据长度
// 01：寻卡命令
// MODE：寻卡模式:0一次只对一张卡操作; 1一次对多张卡操作
// XOR：异或校验值

DLLexport int WINAPI rf_card(HANDLE  icdev,uchar _Mode,ulong *_Snr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;  
	uchar LRC=0;  //异或校验值
	uchar sendbuf[30];
	uchar rebuf[40];
	

    PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);

	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x01;   //命令字
	sendbuf[3]=_Mode;  //寻卡模式
	if (_Mode!=0)
	{
		if (_Mode!=1)
		return -135;   //格式错误
	}
	sendbuf[4]=0;

	//	求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
 
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    
    for(i=0;i<4;i++)
    {
		*((char*)_Snr+i)=rebuf[2+i]; //返回卡的序列号
	}	

	return 0;
}

//初始化系统的工作模式及卡与设备间的通讯速率 
           
//              调用格式：A7 03 12 MODE BAUD XOR  
//                    A7：起始符
//                    03：数据长度
//                    12：初始化系统的工作模式及卡与设备间的通讯速率命令
//                  MODE：系统工作模式，M1卡的缺省值为0xC6
//                  BAUD：卡与设备间的通讯速率，M1卡的缺省值为0x0E
//                   XOR：异或校验值
//         
//              返回格式：A7 02 SIGN 12 XOR 
//                    A7：起始符
//                    02：数据长度
//                  SIGN：返回标志
//                    12：初始化系统的工作模式及卡与设备间的通讯速率命令
//                   XOR：异或校验值

DLLexport int WINAPI rf_config(HANDLE  icdev,uchar _Mode,uchar _Baud)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
    PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);

	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x12;   //命令字
	sendbuf[3]=_Mode;  //系统工作模式，M1卡的缺省值为0xC6
	if (_Mode!=0xC6)
	{
		if (_Mode!=0xD6)
		return -135;   //格式错误
    }
	sendbuf[4]=_Baud;  //卡与设备间的通讯速率，M1卡的缺省值为0x0E
	if (_Baud!=0x0E)
		return -135;   //格式错误
	sendbuf[5]=0;
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[5]=sendbuf[5]^sendbuf[i];
 	}
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
        
	return 0;
}

//寻卡请求 
//              
//              调用格式：A7 02 02 MODE XOR 
//                    A7：起始符
//                    02：数据长度
//                    02：寻卡请求命令
//                  MODE：寻卡模式
//                   XOR：异或校验值
                   	

DLLexport int WINAPI rf_request(HANDLE  icdev,uchar _Mode,uchar *TagType)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x02;   //寻卡请求命令
	sendbuf[3]=_Mode;  //寻卡模式
	if(_Mode!=0x00)  
	{
		if (_Mode!=0x01)
		return -135;   //格式错误
    }
	sendbuf[4]=0;
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	////Sleep(10);
 
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//返回卡类型值，0x0004为M1卡，0x0010为ML卡
	for (i=0;i<2;i++)
	{
		*(TagType+i)=rebuf[2+i];
	}
	return 0;
}

//调用格式：A7 02 03 BCNT XOR  
//                    A7：起始符
//                    02：数据长度
//                    03：防止卡冲突命令
//                  BCNT：预选卡所用的位数，标准值为0
//                   XOR：异或校验值

DLLexport int WINAPI rf_anticoll(HANDLE  icdev,uchar _Bcnt,ulong *_Snr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0; 
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);

	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x03;   //防止卡冲突命令字
	sendbuf[3]=_Bcnt;  //预选卡所用的位数，标准值为0
	if (_Bcnt!=0) 
		return -135;   //格式错误
	sendbuf[4]=0;
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	////Sleep(10);
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	//返回卡的序列号,为4个字节,低位在前
	for(i=0;i<4;i++)
		*((char*)_Snr+i)=rebuf[2+i];
	return 0;
}


//调用格式：A7 05 04 SNR XOR 
//                    A7：起始符
//                    05：数据长度
//                    04：选取一个给定序列号的卡命令
//                   SNR：卡序列号
//                   XOR：异或校验值

DLLexport int WINAPI rf_select(HANDLE  icdev,ulong _Snr,uchar *_Size)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);

	LOGD("tmplong_sn  %X",_Snr);

	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x05;   //数据长度
	sendbuf[2]=0x04;   //选取一个给定序列号的卡命令字
	//所选卡的序列号
	sendbuf[3]=(uchar)(_Snr);
	sendbuf[4]=(uchar)(_Snr>>8);
    sendbuf[5]=(uchar)(_Snr>>16);
	sendbuf[6]=(uchar)(_Snr>>24);
   	sendbuf[7]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[7]=sendbuf[7]^sendbuf[i];
	////Sleep(10);
    SendData_N(icdev,8,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//返回卡的容量
	*(_Size)=rebuf[2];
	return 0;
}

//将密码装入读写模块RAM中： 
              
//调用格式：A7 09 05 MODE SECNR KEY XOR
//      A7：起始符
//      09：数据长度
//      05：将密码装入读写模块RAM中命令
//      MODE：装入密码模式，同密码验证模式
//      SECNR: 扇区号（0～15）
//      KEY: 写入读写器中的卡密码
//      XOR：异或校验值

DLLexport int WINAPI rf_load_key(HANDLE  icdev,uchar _Mode,uchar _SecNr,uchar *_Nkey)
{
    int i;
    uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x09;   //数据长度
	sendbuf[2]=0x05;   //将密码装入读写模块RAM中命令字
	sendbuf[3]=_Mode;  //装入密码模式，同密码验证模式
	sendbuf[4]=_SecNr; //扇区号（0～15）
	//if ((_SecNr>15) || (_SecNr<0))
	//	return -135;    //格式错误
	for(i=0;i<6;i++)
		sendbuf[5+i]=*(_Nkey+i);
	sendbuf[11]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[11]=sendbuf[11]^sendbuf[i];
 
    SendData_N(icdev,12,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//将十六进制密码装入读写模块RAM中： 
              
//调用格式：A7 09 05 MODE SECNR KEY XOR
//      A7：起始符
//      09：数据长度
//      05：将密码装入读写模块RAM中命令
//      MODE：装入密码模式，同密码验证模式
//      SECNR: 扇区号（0～15）
//      KEY: 写入读写器中的卡密码
//      XOR：异或校验值

DLLexport int WINAPI rf_load_key_hex(HANDLE  icdev,uchar _Mode,uchar _SecNr,uchar *_NKey)
{
	int i;
    uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x09;   //数据长度
	sendbuf[2]=0x05;   //将密码装入读写模块RAM中命令字
	sendbuf[3]=_Mode;  //装入密码模式，同密码验证模式
	sendbuf[4]=_SecNr; //扇区号（0～15）
	//if ((_SecNr>15) || (_SecNr<0))
	//	return -135;    //格式错误
    //要装的密码
	for (i=0;i<6;i++)
        sendbuf[5+i]=16*chtohe(*(_NKey+(2*i)))+chtohe(*(_NKey+(2*i+1)));
	sendbuf[11]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[11]=sendbuf[11]^sendbuf[i];
	////Sleep(10);
    SendData_N(icdev,12,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//终止卡操作 
              
//              调用格式：A7 01 06 XOR  
//                    A7：起始符
//                    01：数据长度
//                    06：中止卡操作命令
//                   XOR：异或校验值
//一张卡被终止后,必须把卡拿离感应区或者马上调用
//rf_request函数,而且此时的寻卡模式必须为1
DLLexport int WINAPI rf_halt(HANDLE  icdev)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x01;   //数据长度
	sendbuf[2]=0x06;   //终止卡操作命令字
	sendbuf[3]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[3]=sendbuf[3]^sendbuf[i];
	////Sleep(10);
    SendData_N(icdev,4,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//读取卡中数据
              
//              调用格式：A7 02 07 ADR XOR  
//                    A7：起始符
//                    02：数据长度
//                    07：读取卡中数据命令
//          ADR：M1卡块地址（0～63）；
//                ML卡页地址（0～11）
//                   XOR：异或校验值

DLLexport int WINAPI rf_read(HANDLE  icdev,uchar _Adr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x07;   //读取卡中数据命令字
	sendbuf[3]=_Adr;   //M1卡块地址(0～63),ML卡页地址(0～11)
	//if ((_Adr>63) || (_Adr<0))
	//	return -135;   //格式错误
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	////Sleep(10);
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	//读出的指定地址上的数据,16个字节,对ML卡只有前八个字节有效
	for(i=0;i<16;i++)
	{
		*(_Data+i)=rebuf[2+i];
	}
	return 0;
}


//读多块
DLLexport int WINAPI rf_readM(HANDLE  icdev,uchar _Adr,uchar _Nm,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[300];
	uchar rebuf[400];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x39;   //读取卡中数据命令字
	sendbuf[3]=_Adr;   //M1卡块地址(0～63),ML卡页地址(0～11)
	sendbuf[4]=_Nm;
	sendbuf[5]=0;
	
	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[5]=sendbuf[5]^sendbuf[i];
		
	////Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	//读出的指定地址上的数据,16个字节,对ML卡只有前八个字节有效
	for(i=0;i<len-1;i++)
	{
		*(_Data+i)=rebuf[2+i];
	}	
	return 0;
}


//读取卡中数据,数据以十六进制形式表示
              
//              调用格式：A7 02 07 ADR XOR  
//                    A7：起始符
//                    02：数据长度
//                    07：读取卡中数据命令
//          ADR：M1卡块地址（0～63）；
//                ML卡页地址（0～11）
//                   XOR：异或校验值

DLLexport int WINAPI rf_read_hex(HANDLE  icdev,uchar _Adr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x07;   //读取卡中数据命令字
	sendbuf[3]=_Adr;   //M1卡块地址(0～63),ML卡页地址(0～11)
	//if ((_Adr>63) || (_Adr<0))
	//	return -135;   //格式错误
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	////Sleep(10);
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	//读出的指定地址上的数据,32个字符,对ML卡只有前八个字节有效
	for(i=0;i<16;i++)
    {
		*(_Data+(2*i+1))=rebuf[2+i]&0x0f;
	    *(_Data+(2*i))=(rebuf[2+i]>>4)&0x0f;
	}
	for (i=0;i<32;i++)
    {
       if (((*(_Data+i))>=0x00) && ((*(_Data+i))<=0x09))
           *(_Data+i)=*(_Data+i)+0x30;
       if (((*(_Data+i))>=0x0A) && ((*(_Data+i))<=0x0F))
           *(_Data+i)=*(_Data+i)+0x37;
    }
	return 0;
}
//向卡中写入数据
              
//  调用格式：A7 12 08 ADR DATA XOR 
//  A7：起始符
//  12：数据长度
//  08：向卡中写入数据命令
//  ADR：M1卡块地址(1～63),ML卡页地址(2～11)
//  DATA：要写入的数据
//  XOR：异或校验值

DLLexport int WINAPI rf_write(HANDLE  icdev,uchar _Adr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	//uchar data_len=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x12;   //数据长度
	sendbuf[2]=0x08;   //命令字
	sendbuf[3]=_Adr;   //M1卡块地址(1～63),ML卡页地址(2～11)
	//要写入的数据
	for (i=0;i<16;i++)
	{
	    sendbuf[4+i]=*(_Data+i);
	}
	sendbuf[20]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[20]=sendbuf[20]^sendbuf[i];
	}
	////Sleep(10);
    SendData_N(icdev,21,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}


//写多块
DLLexport int WINAPI rf_writeM(HANDLE  icdev,uchar _Adr,uchar _Nm,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	//uchar data_len=0;
	uchar sendbuf[300];
	uchar rebuf[400];
	uchar wno;
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	wno=_Nm*16;
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=wno+3;   //数据长度
	sendbuf[2]=0x3a;   //命令字
	sendbuf[3]=_Adr;    
	sendbuf[4]=_Nm;
	
	
	//要写入的数据
	for (i=0;i<wno;i++)
	{
	    sendbuf[5+i]=*(_Data+i);
	}    
	sendbuf[5+wno]=0;
	
	//求发送数据包的异或校验值
	LRC=0;
	for(i=0;i<2+sendbuf[1];i++)
	{
		LRC=LRC^sendbuf[i];
	}	
	sendbuf[5+wno]=LRC;
	
	////Sleep(10);
    SendData_N(icdev,wno+6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;
    }
	return 0;
}

//向卡中写入数据,
              
//  调用格式：A7 12 08 ADR DATA XOR 
//  A7：起始符
//  12：数据长度
//  08：向卡中写入数据命令
//  ADR：M1卡块地址(1～63),ML卡页地址(2～11)
//  DATA：要写入的数据
//  XOR：异或校验值

DLLexport int WINAPI rf_write_hex(HANDLE  icdev,uchar _Adr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;

	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x12;   //数据长度
	sendbuf[2]=0x08;   //命令字
	sendbuf[3]=_Adr;   //M1卡块地址(1～63),ML卡页地址(2～11)
	//要写入的数据
	for (i=0;i<16;i++)
        sendbuf[4+i]=16*chtohe(*(_Data+(2*i)))+chtohe(*(_Data+(2*i+1)));
	sendbuf[20]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[20]=sendbuf[20]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,21,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//验证M1卡某一扇区密码 
//           
//              调用格式：A7 03 09 MODE SECNR XOR  
//                    A7：起始符
//                    03：数据长度
//                    09：验证M1卡某一扇区密码命令
//                  MODE：密码验证模式
//                 SECNR：要验证密码的扇区号（0～15）                  
//                   XOR：异或校验值

 DLLexport int WINAPI rf_authentication(HANDLE  icdev,uchar _Mode,uchar _SecNr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x09;   //验证M1卡某一扇区密码命令字
	sendbuf[3]=_Mode;  //密码验证模式
        sendbuf[4]=_SecNr;//要验证密码的扇区号（0～15）
	sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//修改块3的数据 
              
//  调用格式：A7 13 0A SECNR KEYA B0 B1 B2 B3 BK KEYB XOR  
//     A7：起始符
//     13：数据长度
//     0A：修改块3的数据命令
//  SECNR：扇区号（0～15）
//   KEYA：密码A
//     B0：块0控制字，低3位对应C10、C20、C30
//     B1：块1控制字，低3位对应C11、C21、C31
//     B2：块2控制字，低3位对应C12、C22、C32
//     B3：块3控制字，低3位对应C13、C23、C33
//     BK：保留参数，取值为0
//   KEYB：密码B
//    XOR：异或校验值

DLLexport int WINAPI rf_changeb3(HANDLE  icdev,uchar _SecNr,uchar *_KeyA,
						  uchar _B0,uchar _B1,uchar _B2,uchar _B3,
						  uchar _Bk,uchar *_KeyB)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x13;   //数据长度
	sendbuf[2]=0x0A;   //修改块3的数据命令字
	sendbuf[3]=_SecNr; //扇区号（0～15）
	//密码A 6个字节
	for (i=0;i<6;i++)
         sendbuf[4+i]=*(_KeyA+i);
        //sendbuf[4+i]=16*chtohe(*(_KeyA+(2*i)))+chtohe(*(_KeyA+(2*i+1)));
	sendbuf[10]=_B0;   //块0控制字，低3位对应C10、C20、C30
	sendbuf[11]=_B1;   //块1控制字，低3位对应C11、C21、C31
	sendbuf[12]=_B2;   //块2控制字，低3位对应C12、C22、C32
	sendbuf[13]=_B3;   //块3控制字，低3位对应C13、C23、C33
	sendbuf[14]=_Bk;   //保留参数，取值为0

	if (_B0>0x07) 
		return -135;
    if (_B1>0x07) 
		return -135;
	if (_B2>0x07) 
		return -135;
	if (_B3>0x07) 
		return -135;
	if (_Bk!=0) 
		return -135;
	//密码B 6个字节
	for (i=0;i<6;i++)
		sendbuf[15+i]=*(_KeyB+i);
        //sendbuf[15+i]=16*chtohe(*(_KeyB+(2*i)))+chtohe(*(_KeyB+(2*i+1)));
	sendbuf[21]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[21]=sendbuf[21]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,22,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//检测指定数据是否与卡中数据一致
              
//   调用格式：A7 17 0B SNR AUTHMODE ADR DATA XOR  
//   A7：起始符
//   17：数据长度
//   0B：检测指定数据是否与卡中数据一致命令
//   SNR:卡序列号
//   AUTHMODE：与上一次写操作时使用的密码验证模式一致
//   ADR：块地址（1～63）
//   DATA：要检测的数据
//   XOR：异或校验值

 DLLexport int WINAPI rf_check_write(HANDLE  icdev,ulong Snr,uchar authmode,
					   uchar Adr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x17;   //数据长度
	sendbuf[2]=0x0B;   //检测指定数据是否与卡中数据一致命令字
    //卡序列号,4个字节
	sendbuf[3]=(uchar)(Snr);
	sendbuf[4]=(uchar)(Snr>>8);
    sendbuf[5]=(uchar)(Snr>>16);
	sendbuf[6]=(uchar)(Snr>>24);
	sendbuf[7]=authmode;//与上一次写操作时使用的密码验证模式一致
	sendbuf[8]=Adr;     //块地址（1～63）
    //要检测的数据,16个字节
	for (i=0;i<16;i++)
        //sendbuf[9+i]=16*chtohe(*(_Data+(2*i)))+chtohe(*(_Data+(2*i+1)));
	    sendbuf[9+i]=*(_Data+i);
	sendbuf[25]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[25]=sendbuf[25]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,26,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}
//检测指定数据是否与卡中数据一致
              
//   调用格式：A7 17 0B SNR AUTHMODE ADR DATA XOR  
//   A7：起始符
//   17：数据长度
//   0B：检测指定数据是否与卡中数据一致命令
//   SNR:卡序列号
//   AUTHMODE：与上一次写操作时使用的密码验证模式一致
//   ADR：块地址（1～63）
//   DATA：要检测的数据
//   XOR：异或校验值

 DLLexport int WINAPI rf_check_writehex(HANDLE  icdev,ulong Snr,uchar authmode,
					   uchar Adr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x17;   //数据长度
	sendbuf[2]=0x0B;   //检测指定数据是否与卡中数据一致命令字
    //卡序列号,4个字节
	sendbuf[3]=(uchar)(Snr);
	sendbuf[4]=(uchar)(Snr>>8);
    sendbuf[5]=(uchar)(Snr>>16);
	sendbuf[6]=(uchar)(Snr>>24);
	sendbuf[7]=authmode;//与上一次写操作时使用的密码验证模式一致
	sendbuf[8]=Adr;     //块地址（1～63）
    //要检测的数据,16个字节
	for (i=0;i<16;i++)
        sendbuf[9+i]=16*chtohe(*(_Data+(2*i)))+chtohe(*(_Data+(2*i+1)));
	sendbuf[25]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[25]=sendbuf[25]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,26,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

// 高级验证

// 调用格式：A7 08 0C REQMODE SNR AUTHMODE SECNR XOR  
// A7：起始符
// 08：数据长度
// 0C：高级验证命令
// REQMODE：寻卡模式（0：IDLE，一次对一张卡；1：ALL，一次对多张卡；2：指定序列号为SNR的卡）
//    SNR：卡序列号（在寻卡模式为2时需正确指定）
// AUTHMODE：密码验证模式 
// SECNR：扇区号（0～15）
// XOR：异或校验值

 DLLexport int WINAPI rf_HL_authentication(HANDLE  icdev,uchar reqmode,ulong snr,
						  uchar authmode,uchar secnr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符     
	sendbuf[1]=0x08;   //数据长度
	sendbuf[2]=0x0C;   //高级验证命令字
	sendbuf[3]=reqmode;//寻卡模式（0：IDLE，一次对一张卡；
	                   //1：ALL，一次对多张卡；2：指定序列号为SNR的卡）
	sendbuf[4]=(uchar)(snr);//卡序列号（在寻卡模式为2时需正确指定）
	sendbuf[5]=(uchar)(snr>>8);
    sendbuf[6]=(uchar)(snr>>16);
	sendbuf[7]=(uchar)(snr>>24);
	sendbuf[8]=secnr;	  //扇区号（0～15）
	sendbuf[9]=authmode; //密码验证模式 
	sendbuf[10]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[10]=sendbuf[10]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,11,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    
	return 0;
}

 //高级读
              
// 调用格式：A7 07 0D MODE ADR SNR XOR  
//    A7：起始符
//    07：数据长度
//    0D：高级读命令
//  MODE：寻卡模式
//   ADR：块地址（0～63）
//   SNR：卡的序列号
//   XOR：异或校验值

 DLLexport int WINAPI rf_HL_read(HANDLE  icdev,uchar _Mode,uchar _Adr,
						 ulong _Snr,uchar *_Data,ulong *_NSnr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;
	sendbuf[1]=0x07;   //数据长度
	sendbuf[2]=0x0D;   //高级读命令字
	sendbuf[3]=_Mode;  //寻卡模式,同高级验证函数
	sendbuf[4]=_Adr;   //块地址（0～63）
    //卡的序列号
	sendbuf[5]=(uchar)(_Snr);
	sendbuf[6]=(uchar)(_Snr>>8);
        sendbuf[7]=(uchar)(_Snr>>16);
	sendbuf[8]=(uchar)(_Snr>>24);
	sendbuf[9]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[9]=sendbuf[9]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,10,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//读出的数据,16个字节
	for(i=0;i<16;i++)
		*(_Data+i)=rebuf[2+i];
	//返回卡的序列号,4个字节
    for(i=0;i<4;i++)
		*((char*)_NSnr+i)=rebuf[18+i];
	return 0;
}

DLLexport int WINAPI rf_HL_readhex(HANDLE  icdev,uchar _Mode,uchar _Adr,
						 ulong _Snr,uchar *_Data,ulong *_NSnr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;
	sendbuf[1]=0x07;   //数据长度
	sendbuf[2]=0x0D;   //高级读命令字
	sendbuf[3]=_Mode;  //寻卡模式,同高级验证函数
	sendbuf[4]=_Adr;   //块地址（0～63）
    //卡的序列号
	sendbuf[5]=(uchar)(_Snr);
	sendbuf[6]=(uchar)(_Snr>>8);
        sendbuf[7]=(uchar)(_Snr>>16);
	sendbuf[8]=(uchar)(_Snr>>24);
	sendbuf[9]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[9]=sendbuf[9]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,10,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	//读出的指定地址上的数据,32个字符
	for(i=0;i<16;i++)
    {
		*(_Data+(2*i+1))=rebuf[2+i]&0x0f;
	    *(_Data+(2*i))=(rebuf[2+i]>>4)&0x0f;
	}
	for (i=0;i<32;i++)
    {
       if (((*(_Data+i))>=0x00) && ((*(_Data+i))<=0x09))
           *(_Data+i)=*(_Data+i)+0x30;
       if (((*(_Data+i))>=0x0A) && ((*(_Data+i))<=0x0F))
           *(_Data+i)=*(_Data+i)+0x37;
    }
	//返回卡的序列号,4个字节
    for(i=0;i<4;i++)
		*((char*)_NSnr+i)=rebuf[18+i];
	return 0;
}

// 高级写
              
//  调用格式：A7 17 0E MODE ADR DATA SNR XOR 
//  A7：起始符
//  17：数据长度
//  0E：高级写命令
//  MODE：寻卡模式, 同高级验证函数
//  ADR：块地址（1～63）
//  DATA：写入的数据
//  SNR：卡的序列号
//  XOR：异或校验值

 DLLexport int WINAPI rf_HL_write(HANDLE  icdev,uchar _Mode,uchar _Adr,
						 ulong _Snr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x17;   //数据长度
	sendbuf[2]=0x0E;   //高级写命令字
	sendbuf[3]=_Mode;  //寻卡模式, 同高级验证函数
	sendbuf[4]=_Adr;   //块地址（1～63）
    //卡的序列号
	//写入的数据,16个字节
	for (i=0;i<16;i++)
        sendbuf[5+i]=*(_Data+i);

	sendbuf[21]=(uchar)(_Snr);
	sendbuf[22]=(uchar)(_Snr>>8);
    sendbuf[23]=(uchar)(_Snr>>16);
	sendbuf[24]=(uchar)(_Snr>>24);
	
	//求发送数据包的异或校验值
	sendbuf[25]=0;
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[25]=sendbuf[25]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,26,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

// 高级写
              
//  调用格式：A7 17 0E MODE ADR DATA SNR XOR 
//  A7：起始符
//  17：数据长度
//  0E：高级写命令
//  MODE：寻卡模式, 同高级验证函数
//  ADR：块地址（1～63）
//  DATA：写入的数据
//  SNR：卡的序列号
//  XOR：异或校验值

 DLLexport int WINAPI rf_HL_writehex(HANDLE  icdev,uchar _Mode,uchar _Adr,
						 ulong _Snr,uchar *_Data)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x17;   //数据长度
	sendbuf[2]=0x0E;   //高级写命令字
	sendbuf[3]=_Mode;  //寻卡模式, 同高级验证函数
	sendbuf[4]=_Adr;   //块地址（1～63）
    //卡的序列号
 
	//写入的数据,16个字节
	for (i=0;i<16;i++)
        sendbuf[5+i]=16*chtohe(*(_Data+(2*i)))+chtohe(*(_Data+(2*i+1)));

    sendbuf[21]=(uchar)(_Snr);
	sendbuf[22]=(uchar)(_Snr>>8);
    sendbuf[23]=(uchar)(_Snr>>16);
	sendbuf[24]=(uchar)(_Snr>>24);
	//求发送数据包的异或校验值
	sendbuf[25]=0;
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[25]=sendbuf[25]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,26,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//ML卡验证密码
              
//    调用格式：A7 04 0F MODE KEYNR ADR XOR 
//          A7：起始符
//          04：数据长度
//          0F：ML卡验证密码命令
//        MODE：密码验证模式（0 KEYA；4 KEYB）
//       KEYNR：=0
//         ADR：=0
//         XOR：异或校验值

 DLLexport int WINAPI rf_authentication_2(HANDLE  icdev,uchar _Mode,uchar KeyNr,uchar Adr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x04;   //数据长度
	sendbuf[2]=0x0F;   //ML卡验证密码命令字
	sendbuf[3]=_Mode;  //密码验证模式（0 KEYA；4 KEYB）
        sendbuf[4]=KeyNr;//KEYNR：=0
	sendbuf[5]=Adr;    //ADR：=0

	//求发送数据包的异或校验值
	sendbuf[6]=0;
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[6]=sendbuf[6]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,7,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//蜂鸣  
           
//              调用格式：A7 03 14 MSCE XOR  
//                    A7：起始符
//                    03：数据长度
//                    14：蜂鸣命令
//                  MSCE：蜂鸣时限，单位是10毫秒，为2个字节
//                   XOR：异或校验值

DLLexport int WINAPI rf_beep(HANDLE  icdev,uint _Msec)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x14;   //蜂鸣命令字
	//蜂鸣时限，单位是10毫秒，为2个字节
	sendbuf[3]=_Msec%256;
	sendbuf[4]=_Msec/256;
    sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	//Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//设置自动读卡
DLLexport int WINAPI rf_autoread(HANDLE  icdev,long flg)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	uchar bps;
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
 

	if(flg==0)
	{
		bps=0;
	}
	else 
	{
		bps=1;
	}


	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x40;   //设置自动读卡
	
	sendbuf[3]=bps;
	sendbuf[4]=0x00;
    sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	}
	//Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	return 0;

}




//修改波特率
DLLexport int WINAPI rf_changbps(HANDLE  icdev,long baud)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	uchar bps;
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
 

	if(baud==9600)
	{
		bps=0;
	}
	else if(baud==19200)
	{
		bps=1;
	}
	else if(baud==38400)
	{
		bps=2;
	}
	else if(baud==57600)
	{
		bps=3;
	}
	else if(baud==115200)
	{
		bps=4;
	}
	else
	{
		bps=0;
	}

	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x15;   //修改读写器的通讯速率
	
	sendbuf[3]=bps;
	sendbuf[4]=0x00;
    sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	}
	//Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	return 0;

}

//输出继电器
DLLexport int WINAPI rf_outputIO(HANDLE  icdev,uchar o_NO,uchar o_lev)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x49;   //输出继电器
	
	sendbuf[3]=o_NO;
	sendbuf[4]=o_lev;
    sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	}
	//Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//输入数据
DLLexport int WINAPI rf_inputIO(HANDLE  icdev,uchar *o_lev)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x4a;   //输入数据
	
	sendbuf[3]=0x00;
	sendbuf[4]=0x0;
    sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	}
	//Sleep(10);
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	o_lev[0]=rebuf[2+0];
	o_lev[1]=rebuf[2+1];

	return 0;
}


//取得读写器硬件版本号
              
//              调用格式：A7 01 11 XOR  
//                    A7：起始符
//                    01：数据长度
//                    11：取得读写器硬件版本号命令
//                   XOR：异或校验值

DLLexport int WINAPI rf_get_status(HANDLE icdev,uchar * _Status)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x01;   //数据长度
	sendbuf[2]=0x11;   //取得读写器硬件版本号命令字
	sendbuf[3]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[3]=sendbuf[3]^sendbuf[i];
    SendData_N(icdev,4,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//取得的版本信息
	for (i=0;i<14;i++)
		*(_Status+i)=rebuf[2+i];
    return 0;
}

//初始化块值  
           
//              调用格式：A7 06 16 ADR VALUE XOR  
//                    A7：起始符
//                    06：数据长度
//                    16：初始化块值命令
//                   ADR：块地址（1～63）
//                 VALUE：初始值，为4个字节
//                   XOR：异或校验值

DLLexport int WINAPI rf_initval(HANDLE icdev,uchar _Adr,ulong _Value)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x06;   //数据长度
	sendbuf[2]=0x16;   //命令字
	sendbuf[3]=_Adr;   //块地址（1～63）
    //初始值，为4个字节
	sendbuf[4]=(uchar)(_Value);
	sendbuf[5]=(uchar)(_Value>>8);
    sendbuf[6]=(uchar)(_Value>>16);
	sendbuf[7]=(uchar)(_Value>>24);
	sendbuf[8]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[8]=sendbuf[8]^sendbuf[i];
    SendData_N(icdev,9,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    return 0;
}

//块加值
           
//              调用格式：A7 06 17 ADR VALUE XOR  
//                    A7：起始符
//                    06：数据长度
//                    17：块加值命令
//                   ADR：块地址（1～63）
//                 VALUE：要增加的值
//                     XOR：异或校验值

DLLexport int WINAPI rf_increment(HANDLE icdev,uchar _Adr,ulong _Value)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x06;   //数据长度
	sendbuf[2]=0x17;   //块加值命令字
	sendbuf[3]=_Adr;   //块地址（1～63）
	//要增加的值
	sendbuf[4]=(uchar)(_Value);
	sendbuf[5]=(uchar)(_Value>>8);
        sendbuf[6]=(uchar)(_Value>>16);
	sendbuf[7]=(uchar)(_Value>>24);
	sendbuf[8]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[8]=sendbuf[8]^sendbuf[i];
    SendData_N(icdev,9,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    return 0;
}

//块减值  
           
//              调用格式：A7 06 18 ADR VALUE XOR  
//                    A7：起始符
//                    06：数据长度
//                    18：块减值命令
//                   ADR：块地址（1～63）
//                 VALUE：要减的值
//                   XOR：异或校验值

DLLexport int WINAPI rf_decrement(HANDLE icdev,uchar _Adr,ulong _Value)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x06;   //数据长度
	sendbuf[2]=0x18;   //块减值命令字
	sendbuf[3]=_Adr;   //块地址（1～63）
	//要减的值,4个字节
	sendbuf[4]=(uchar)(_Value);
	sendbuf[5]=(uchar)(_Value>>8);
        sendbuf[6]=(uchar)(_Value>>16);
	sendbuf[7]=(uchar)(_Value>>24);
	sendbuf[8]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[8]=sendbuf[8]^sendbuf[i];
    SendData_N(icdev,9,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    return 0;
}

//读块值  

//              调用格式：A7 02 19 ADR XOR  
//                    A7：起始符
//                    02：数据长度
//                    19：读块值命令
//                   ADR：块地址（1～63）
//                   XOR：异或校验值

DLLexport int WINAPI rf_readval(HANDLE icdev,uchar _Adr,ulong *_Value)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x19;   //读块值命令字
	sendbuf[3]=_Adr;   //块地址（1～63）
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
		
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//读出的值
    for(i=0;i<4;i++)
		*((char*)_Value+i)=rebuf[2+i];
    return 0;
}

//将EEPROM中的内容传入卡的内部寄存器  
           
//              调用格式：A7 02 1A ADR XOR  
//                    A7：起始符
//                    02：数据长度
//                    1A：将EEPROM中的内容传入卡的内部寄存器命令
//                   ADR：要进行回传的块地址（1～63）
//                   XOR：异或校验值

DLLexport int WINAPI rf_restore(HANDLE icdev,uchar _Adr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x1a;   //将EEPROM中的内容传入卡的内部寄存器命令字
	sendbuf[3]=_Adr;   //要进行回传的块地址（1～63）
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    return 0;
}

//将寄存器的内容传送到EEPROM中
           
//              调用格式：A7 02 1B ADR XOR  
//                    A7：起始符
//                    02：数据长度
//                    1B：将寄存器的内容传送到EEPROM中命令
//                   ADR：要传送的地址（1～63）
//                   XOR：异或校验值

DLLexport int WINAPI rf_transfer(HANDLE icdev,uchar _Adr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x1b;   //将寄存器的内容传送到EEPROM中命令字
	sendbuf[3]=_Adr;   //要传送的地址（1～63）
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    return 0;
}

//高级初始化值  
           
//              调用格式：A7 0B 1C MODE SECNR VALUE SNR XOR  
//                    A7：起始符
//                    0B：数据长度
//                    1C：高级初始化值命令
//                  MODE：寻卡模式
//                 SECNR：扇区号（0～15）
//                 VALUE：初始值
//                   SNR：卡的序列号
//                   XOR：异或校验值

DLLexport int WINAPI rf_HL_initval(HANDLE  icdev,uchar _Mode,uchar _SecNr,
							ulong _Value,ulong *_Snr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x0b;   //数据长度
	sendbuf[2]=0x1C;   //高级初始化值命令字
	sendbuf[3]=_Mode;  //寻卡模式
	sendbuf[4]=_SecNr; //扇区号（0～15）
	//初始值
	sendbuf[5]=(uchar)(_Value);
	sendbuf[6]=(uchar)(_Value>>8);
    sendbuf[7]=(uchar)(_Value>>16);
	sendbuf[8]=(uchar)(_Value>>24);
	//卡的序列号
	for (i=0;i<4;i++)
    	sendbuf[9+i]=*((char*)_Snr+i);
	sendbuf[13]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[13]=sendbuf[13]^sendbuf[i];

    SendData_N(icdev,14,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	return 0;
}

//高级增值操作  
           
// 调用格式：A7 0B 1D MODE SECNR VALUE SNR XOR 
// A7：起始符
// 0B：数据长度
// 1D：高级增值操作命令
// MODE：寻卡模式
// SECNR：扇区地址（0～15）
// VALUE：要加的值
// SNR：卡的序列号
// XOR：异或校验值

DLLexport int WINAPI rf_HL_increment(HANDLE  icdev,uchar _Mode,uchar _SecNr,
		ulong _Value,ulong _Snr,ulong *_NValue,ulong *_NSnr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x0b;   //数据长度
	sendbuf[2]=0x1d;   //高级增值操作命令字
	sendbuf[3]=_Mode;  //寻卡模式
	sendbuf[4]=_SecNr; //扇区地址（0～15）
	//要加的值
	sendbuf[5]=(uchar)(_Value);
	sendbuf[6]=(uchar)(_Value>>8);
    sendbuf[7]=(uchar)(_Value>>16);
	sendbuf[8]=(uchar)(_Value>>24);
	//卡的序列号
	sendbuf[9]=(uchar)(_Snr);
	sendbuf[10]=(uchar)(_Snr>>8);
    sendbuf[11]=(uchar)(_Snr>>16);
	sendbuf[12]=(uchar)(_Snr>>24);
	
	//求发送数据包的异或校验值
	sendbuf[13]=0;
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[13]=sendbuf[13]^sendbuf[i];

    SendData_N(icdev,14,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//加后的值
    for(i=0;i<4;i++)
		*((char*)_NValue+i)=rebuf[2+i];
	//返回卡的序列号
    for(i=0;i<4;i++)
		*((char*)_NSnr+i)=rebuf[6+i];
	return 0;
}

//高级减值操作  
           
//              调用格式：A7 0B 1E MODE SECNR VALUE SNR XOR  
//                    A7：起始符
//                    0B：数据长度
//                    1E：高级减值操作命令
//                  MODE：寻卡模式
//                 SECNR：扇区地址（0～15）
//                 VALUE：要减的值
//                   SNR：卡的序列号
//                   XOR：异或校验值

DLLexport int WINAPI rf_HL_decrement(HANDLE  icdev,uchar _Mode,uchar _SecNr,
		ulong _Value,ulong _Snr,ulong *_NValue,ulong *_NSnr)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x0b;   //数据长度
	sendbuf[2]=0x1e;   //命令字
	sendbuf[3]=_Mode;  //寻卡模式
	sendbuf[4]=_SecNr; //扇区地址（0～15）
	//要减的值
	sendbuf[5]=(uchar)(_Value);
	sendbuf[6]=(uchar)(_Value>>8);
    sendbuf[7]=(uchar)(_Value>>16);
	sendbuf[8]=(uchar)(_Value>>24);
	//卡的序列号
	sendbuf[9]=(uchar)(_Snr);
	sendbuf[10]=(uchar)(_Snr>>8);
    sendbuf[11]=(uchar)(_Snr>>16);
	sendbuf[12]=(uchar)(_Snr>>24);
	
	//求发送数据包的异或校验值
	sendbuf[13]=0;
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[13]=sendbuf[13]^sendbuf[i];

    SendData_N(icdev,14,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	//减后的值
    for(i=0;i<4;i++)
		*((char*)_NValue+i)=rebuf[2+i];
	//返回卡的序列号
	 for(i=0;i<4;i++)
		*((char*)_NSnr+i)=rebuf[6+i];
	return 0;
}

//ML卡初始化值
           
//              调用格式：A7 03 1F VALUE XOR  
//                    A7：起始符
//                    03：数据长度
//                    1F：ML卡初始化值命令
//                 VALUE：初始值，为2个字节
//                   XOR：异或校验值

DLLexport int WINAPI rf_initval_ml(HANDLE icdev,uint _Value)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x1f;   //ML卡初始化值命令字
	//初始值，为2个字节
	sendbuf[3]=(uchar)(_Value);
	sendbuf[4]=(uchar)(_Value>>8);
    sendbuf[5]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[5]=sendbuf[5]^sendbuf[i];
		
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
    return 0;
}

//ML卡读值操作  
           
//              调用格式：A7 01 20 XOR  
//                    A7：起始符
//                    01：数据长度
//                    20：ML卡读值操作命令
//                   XOR：异或校验值

DLLexport int WINAPI rf_readval_ml(HANDLE icdev,uint *_Value)
{
  return 0;
}

//ML卡减值操作  
           
//              调用格式：A7 04 21 ADR VALUE XOR  
//                    A7：起始符
//                    04：数据长度
//                    21：ML卡减值操作命令
//                   ADR：=0
//                 VALUE：要减的值
//                   XOR：异或校验值

DLLexport int WINAPI rf_decrement_transfer(HANDLE icdev,uchar Adr,ulong _Value)
{
 
    return 0;
}

//ML卡修改密码操作  
           
//              调用格式：A7 14 22 MODE SNR AC0 AC1 KEYB XOR 
//                    A7：起始符
//                    14：数据长度
//                    22：ML卡修改密码操作命令
//                  MODE: 寻卡模式, 同高级验证函数
//                   SNR: 卡的序列号
//                  KEYA: 新密码A
//                   AC0: 密码A存取控制字
//                   AC1: 密码B存取控制字
//                  KEYB: 新密码B 
//                   XOR：异或校验值

DLLexport int WINAPI rf_change_ml(HANDLE  icdev,uchar _Mode,ulong _Snr,
		uchar *_KeyA,uchar _AC0,uchar _AC1,uchar *_KeyB,ulong *_NSnr)
{
 return 0;
}

DLLexport int  WINAPI  rf_lib_ver(uchar *buff)
{
	strcpy((char *)buff,"DH-RD-DLL-V3.0-131123");

	return 0;
}



 //标准请求
 //调用格式：A7 02 30 MODE XOR 
//rmode :请求模式		或 0x52,0x26
DLLexport int WINAPI rf_ISO14443A_request(HANDLE icdev,uchar rmode,uchar *atq)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;	//起始符
	sendbuf[1]=0x02;	//数据长度
	sendbuf[2]=0x30;	//操作命令字
	sendbuf[3]=rmode;	//请求模式
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	atq[0]=rebuf[2];
	atq[1]=rebuf[3];
    return 0;
}

DLLexport int WINAPI rf_ISO14443A_anticoll(HANDLE icdev,uchar cmd,uchar *snr)
{

	    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;	//起始符
	sendbuf[1]=0x02;	//数据长度
	sendbuf[2]=0x31;	//操作命令字
	sendbuf[3]=cmd;	    //级别命令
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
 
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	snr[0]=rebuf[2];
	snr[1]=rebuf[3];
  	snr[2]=rebuf[4];
	snr[3]=rebuf[5];
	snr[4]=rebuf[6];

	return 0;
}

DLLexport int WINAPI rf_ISO14443A_select(HANDLE icdev,uchar cmd,uchar *snr)
{
		    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;	//起始符
	sendbuf[1]=0x06;	//数据长度
	sendbuf[2]=0x32;	//操作命令字
	sendbuf[3]=cmd;	    //级别命令
	
	sendbuf[4]=snr[0];
	sendbuf[5]=snr[1];
  	sendbuf[6]=snr[2];
	sendbuf[7]=snr[3];

	sendbuf[8]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[8]=sendbuf[8]^sendbuf[i];
	}
    SendData_N(icdev,9,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
 
	return rebuf[0];
}



DLLexport int WINAPI rf_ISO14443A_sendpkt(HANDLE icdev,
										 unsigned char crc_enable, 
										 unsigned char slen, 
										 unsigned char *sbuf,
										 unsigned char *rlen, 
										 unsigned char *rbuf)
{
		    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[300];
	uchar rebuf[400];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;			//起始符
	sendbuf[1]=slen+3;			//数据长度
	sendbuf[2]=0x33;			//操作命令字
	sendbuf[3]=crc_enable;	    //发送时是否附加CRC
	sendbuf[4]=slen;			//发送长度	

	for (i=0;i<slen;i++)
	{
		sendbuf[5+i]=sbuf[i];
	}
	len=sendbuf[1]+2;

	//求发送数据包的异或校验值
	for(i=0;i<len;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[len]=LRC;


    SendData_N(icdev,len+1,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	len=len-2;	//2byte 状态，命令字，3byte 卡片控制字
	memcpy(rbuf,&rebuf[2],len);
	rlen[0]	=len;

	return rebuf[0];
}

 


 

//寻卡
DLLexport int WINAPI rf_ISO14443A_findcard(HANDLE icdev,uchar wmode,uchar *rlen,uchar *serial_nm)
{

     int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;	//起始符
	sendbuf[1]=0x02;	//数据长度
	sendbuf[2]=0x38;	//操作命令字
	sendbuf[3]=wmode;	//请求模式
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
 
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	rlen[0]=rebuf[2];
	memcpy(serial_nm,&rebuf[3],rebuf[2]);
	
    return 0;
	
}



DLLexport int WINAPI rf_ISO14443A_ATS(HANDLE icdev,uchar *rlen,uchar *buf)
{
 		int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x35;   //寻卡请求命令
	sendbuf[3]=0;
	sendbuf[4]=0;
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	//len=len-2;
	memcpy(buf,&rebuf[2],rebuf[2]);

	rlen[0]=rebuf[2];
	return 0;
 
}



DLLexport short WINAPI rf_ISO14443A_APDU(HANDLE icdev,unsigned char slen,unsigned char *send,unsigned char *rlen, unsigned char *receive)
{
	int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[300];
	uchar rebuf[400];
	
	ulong card_state;

	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;			//起始符
	sendbuf[1]=slen+2;			//数据长度
	sendbuf[2]=0x36;			//操作命令字
	sendbuf[3]=(uchar)slen;		//发送长度	

	for (i=0;i<slen;i++)
	{
		sendbuf[4+i]=send[i];
	}
	len=sendbuf[1]+2;

	//求发送数据包的异或校验值
	for(i=0;i<len;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[len]=LRC;

 

    SendData_N(icdev,len+1,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return 0x6ff1;	
    }
	if(rebuf[0]!=0x00)
	{
		return 0x6ff2;
	}

	len	=rebuf[2];
	
	len=len-2;

	if(len>0)
	{
		
		memcpy(receive,&rebuf[3],len	);	
		card_state=rebuf[3+len];
		card_state=(card_state<<8)+rebuf[3+len+1];
		rlen[0]=len;
		///////////////////////////////////////按照广电运通的返回值要求修改,2011-7-29	
		receive[len]=rebuf[3+len];
		receive[len+1]=rebuf[3+len+1];
		rlen[0]=len+2;
		/////////////////////////////////////////
		
	}
	else
	{
		
		card_state=rebuf[3];
		card_state=(card_state<<8)+rebuf[4];
		rlen[0]=2;
		receive[len]=rebuf[3];
		receive[len+1]=rebuf[4];
	
	}


	return card_state&0xffff;
 

}




 


DLLexport int WINAPI rf_ISO14443A_Deselect(HANDLE icdev)
{
 
	int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x37;   //   下电
	sendbuf[3]=0;		// 
	sendbuf[4]=0;

	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
 
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
 

	return 0;
}


//ulight 卡
DLLexport int WINAPI rf_UL_findcard(HANDLE icdev,uchar wmode,uchar *len,uchar *serial_nm)
{
	return rf_ISO14443A_findcard(icdev,wmode,len,serial_nm);
}

//读块地址
DLLexport int WINAPI rf_UL_read(HANDLE  icdev,uchar _Adr,uchar *_Data)
{
	uchar rbuf[32];
	int rt;
	rt= rf_read(icdev,_Adr,rbuf);
	memcpy(_Data,rbuf,4);
	return rt;
}

//写卡
DLLexport int WINAPI rf_UL_write(HANDLE  icdev,uchar _Adr,uchar *_Data)
{
	uchar rbuf[32];
	int rt;
	memcpy(rbuf,_Data,4);
	rt=rf_write(icdev,_Adr,rbuf);
	return rt;

}

//读多块
DLLexport int WINAPI rf_UL_readM(HANDLE  icdev,uchar _Adr,uchar _Nm,uchar *_Data)
{
 	return rf_readM(icdev,_Adr,_Nm,_Data);
//	return 0x1;
}

DLLexport int WINAPI rf_UL_writeM(HANDLE  icdev,uchar _Adr,uchar _Nm,uchar *_Data)
{
	uchar wbuf[200];
	uchar i;
	
	int rt;
	for(i=0;i<_Nm;i++)
	{
		memcpy(&wbuf[i*16],&_Data[i*4],4);
	}
	return rf_writeM(icdev,_Adr,_Nm,wbuf);
//	return 1;
}

//射频接口复位
DLLexport int WINAPI rf_rfinf_reset(HANDLE icdev,uchar rflag)
{

	int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;	//起始符
	sendbuf[1]=0x02;	//数据长度
	sendbuf[2]=0x34;	//操作命令字
	sendbuf[3]=rflag;
	sendbuf[4]=0;

	//求发送数据包的异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
 

    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
 
	return rebuf[0];
	
}


//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------

DLLexport int WINAPI   ISO15693_Inventory(HANDLE icdev,unsigned char flags,unsigned char AFI,unsigned char masklengh ,unsigned char *maskvalue,unsigned char*databuffer)
{
	
	int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=4;
	
	sendbuf[2]=0x60;   //CMD_ISO15693_INVENTORY	
	sendbuf[3]=flags;
	sendbuf[4]=AFI;
	sendbuf[5]=masklengh;
  
 
	for (i=0;i<masklengh;i++)
	{
		sendbuf[6+i]=maskvalue[i];
	}
	
	sendlen=sendlen+masklengh;
	
	sendbuf[1]=sendlen;			//datalen
	

	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
  //recbuf[0],status,
  //recbuf[1],command,
  //recbuf[2],data start,

  memcpy(databuffer,&rebuf[2],reclen-2);
  //outlen[0]=reclen-2;


	return 0;
	
}

DLLexport int WINAPI   ISO15693_Stay_Quiet(HANDLE icdev,unsigned char flags,unsigned char*UID)
{
	
		int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x61;   //CMD_ISO15693_STAY_QUIET	
	sendbuf[3]=flags;
  
 
	for (i=0;i<8;i++)
	{
		sendbuf[4+i]=UID[i];
	}
	
	sendlen=sendlen+8;
	
	sendbuf[1]=sendlen;			//datalen
	

	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;
}

DLLexport int WINAPI   ISO15693_Read(HANDLE icdev,unsigned char flags,unsigned char Firstblock, unsigned char Number,unsigned char*UID,unsigned char*databuffer)
{
			int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=4;
	
	sendbuf[2]=0x62;   	//MRC632 15693 read  block
	sendbuf[3]=flags;
  sendbuf[4]=Firstblock;
  sendbuf[5]=Number;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[6+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
  
  memcpy(databuffer,&rebuf[3],reclen-3);
  return 0;

}

DLLexport int WINAPI   ISO15693_Write(HANDLE icdev,unsigned char flags,unsigned char Firstblock,unsigned char Number,unsigned char*UID,unsigned char*databuffer)
{
			int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=4;
	
	sendbuf[2]=0x63;   	//CMD_ISO15693_WRITE
	sendbuf[3]=flags;
	sendbuf[4]=Firstblock;
	sendbuf[5]=Number;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[6+i]=UID[i];
		}
		sendlen=sendlen+8;
	}
	memcpy(&sendbuf[6+8],databuffer,Number*4);
	sendlen=sendlen+Number*4;

	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;		

	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;	
}

DLLexport int WINAPI   ISO15693_Lock_Block(HANDLE icdev,unsigned char flags,unsigned char block,unsigned char*UID)
{
			int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=3;
	
	sendbuf[2]=0x64;   	//CMD_ISO15693_LOCK_BLOCK
	sendbuf[3]=flags;
  sendbuf[4]=block;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[5+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;	
}

DLLexport int WINAPI   ISO15693_Select(HANDLE icdev,unsigned char flags,unsigned char*UID)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x65;   	//CMD_ISO15693_SELECT
	sendbuf[3]=flags;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;	
}

DLLexport int WINAPI   ISO15693_Reset_To_Ready(HANDLE icdev,unsigned char flags,unsigned char*UID)
{
			int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x66;   	//CMD_ISO15693_RESET_TO_READY
	sendbuf[3]=flags;
                
	//if (flags&0x20)
	//{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	//}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;		
}

DLLexport int WINAPI  ISO15693_Write_AFI(HANDLE icdev,unsigned char flags, unsigned char AFI, unsigned char*UID)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=3;
	
	sendbuf[2]=0x67;   	//CMD_ISO15693_WRITE_AFI
	sendbuf[3]=flags;
  sendbuf[4]=AFI;
               
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[5+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;	
}

DLLexport int WINAPI  ISO15693_Lock_AFI(HANDLE icdev,unsigned char flags,unsigned char*UID)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x68;   	//CMD_ISO15693_LOCK_AFI
	sendbuf[3]=flags;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;		
}

DLLexport  int WINAPI  ISO15693_Write_DSFID(HANDLE icdev,unsigned char flags,unsigned char DSFID,unsigned char*UID)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=3;
	
	sendbuf[2]=0x69;   	//CMD_ISO15693_WRITE_DSFID
	sendbuf[3]=flags;
  sendbuf[4]=DSFID;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;	
}

DLLexport int WINAPI  ISO15693_Lock_DSFID(HANDLE icdev,unsigned char flags,unsigned char*UID)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x6a;   	//CMD_ISO15693_LOCK_DSFID
	sendbuf[3]=flags;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;	
}

DLLexport int WINAPI  ISO15693_GET_System_Information(HANDLE icdev,unsigned char flags,unsigned char*UID,unsigned char *databuffer,unsigned char *rlen)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x6B;   	//CMD_ISO15693_GET_SYSTEM_INFORMATION
	sendbuf[3]=flags;
                
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
    memcpy(databuffer,&rebuf[3],reclen-3);
	rlen[0]=reclen-3;
	return 0;		
}

DLLexport int WINAPI  ISO15693_GetMultipleBlockSecurity(HANDLE icdev,unsigned char flags,unsigned char Firstblock,unsigned char Number,unsigned char*UID,unsigned char*databuffer)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x6C;   	//CMD_ISO15693_GET_MULTIPLE_BLOCK_SECURITY
	sendbuf[3]=flags;
	sendbuf[3]=Firstblock;
  sendbuf[3]=Number;
  	              
	if (flags&0x20)
	{
		for (i=0;i<8;i++)
		{
			sendbuf[4+i]=UID[i];
		}
		sendlen=sendlen+8;
	}

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rt;	
  }
	return 0;		
}

DLLexport int WINAPI  ISO15693_Generic(HANDLE icdev,unsigned char length,unsigned char *databuffer,unsigned char *outlen,unsigned char *outbuffer)
{
				int i;
	uchar t=0,rt=0;
	uchar sendlen=0;
	uchar reclen=0;
	
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x00;   //数据长度
	
	sendlen=2;
	
	sendbuf[2]=0x6D;   	//CMD_ISO15693_GENERIC
	sendbuf[3]=length;
                
		for (i=0;i<length;i++)
		{
			sendbuf[4+i]=databuffer[i];
		}
		sendlen=sendlen+length;

	
	sendbuf[1]=sendlen;			//datalen
	
	//求发送数据包的异或校验值
	sendlen=sendlen+2;			
	LRC=0;
	for(i=0;i<sendlen;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[sendlen]=LRC;
	sendlen=sendlen+1;			
	
  SendData_N(icdev,sendlen,sendbuf);
  reclen=0;
  rt=RecData_N(icdev,&reclen,rebuf);
  if(rt!=0)
  {
    	return rebuf[0];	
  }
  //recbuf[0],status,
  //recbuf[1],command,
  //recbuf[2],data start,

  memcpy(outbuffer,&rebuf[2],reclen-2);
  outlen[0]=reclen-2;

  return 0;

}




//* 返回的len为实际字节数
DLLexport long WINAPI cpu_reset(HANDLE icdev,unsigned char  *rlen,unsigned char  *buf)
{
		int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x71;   //寻卡请求命令
	sendbuf[3]=0;
	sendbuf[4]=0;
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
	////Sleep(10);
 

    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	len=len-2;
	memcpy(buf,&rebuf[2],len);

	rlen[0]=len;
	return 0;
 
}

//非标准复位
//* 返回的len为实际字节数
DLLexport long WINAPI cpu_reset2(HANDLE icdev,unsigned char baud,unsigned char ucVoltage ,unsigned char  *rlen,unsigned char  *buf)
{
		int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x03;   //数据长度
	sendbuf[2]=0x75;   //寻卡请求命令
	sendbuf[3]=baud;
	sendbuf[4]=ucVoltage;
	sendbuf[5]=0;
	
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[5]=sendbuf[5]^sendbuf[i];
	}
	////Sleep(10);
 
    SendData_N(icdev,6,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }

	len=len-2;
	memcpy(buf,&rebuf[2],len);

	rlen[0]=len;
	return 0;
 
}
  //CPU卡下电函数
DLLexport  long WINAPI cpu_power_off(HANDLE icdev)
{
	int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x74;   //   下电
	sendbuf[3]=0;		// 
	sendbuf[4]=0;

	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		sendbuf[4]=sendbuf[4]^sendbuf[i];
	}
 
 
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
 

	return 0;
}

  //向下位机发送命令(FOR CPU卡)
/*发送的缓冲区send包括给下位机的命令及数据(字符),格式是:
	CLA		指令类别
	INS		指令类型的指令码
	P1		命令参数1
	P2		命令参数2
	Lc		数据域DATA长度,该长度不可超过178字节
	DATA	数据域或应答数据域
	Le		要求返回数据长度,Le为00表示返回卡中最大数据长度,该长度不可超过178字节
  slen是指整个缓冲区的长度
  rlen是指要接收数据的长度n   rlen=IC卡实际返回字节数
  通讯正常，则返回SW2,否则返回FFFF
  */
DLLexport  unsigned long WINAPI cpu_access(HANDLE icdev,unsigned char slen,unsigned char  *send,unsigned char *rlen,unsigned char *receive)
{
 
	unsigned long i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[300];
	uchar rebuf[400];
	
	ulong card_state;

	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	
	sendbuf[0]=0xa7;			//起始符
	sendbuf[1]=(uchar)(slen+2);			//数据长度
	sendbuf[2]=0x72;			//操作命令字
	sendbuf[3]=(uchar)slen;			//发送长度	

	for (i=0;i<slen;i++)
	{
		sendbuf[4+i]=send[i];
	}
	len=sendbuf[1]+2;

	//求发送数据包的异或校验值
	for(i=0;i<len;i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[len]=LRC;
 
    SendData_N(icdev,len+1,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return 0x6ff1;	
    }
	if(rebuf[0]!=0x00)
	{
		return 0x6ff2;
	}

	len	=rebuf[2];

	
	memcpy(receive,&rebuf[3],len	);

	card_state=rebuf[3+len];
	card_state=(card_state<<8)+rebuf[3+len+1];
	rlen[0]=len;

	return card_state;
	
}

 //选择CPU卡卡座(0~3，第3卡座用于双界面卡)
DLLexport  long WINAPI cpu_selsocket(HANDLE icdev,unsigned char samso)
{
		    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x70;   //寻卡请求命令
	sendbuf[3]=samso;  //卡座
	sendbuf[4]=0;

	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];

	////Sleep(10);
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }


	return 0;
}

//读取当前CPU卡座位置(0~3)
DLLexport  long  WINAPI cpu_getsocket(HANDLE icdev,unsigned char *samso )
{
			    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];
	
	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x73;   //得到当前卡座
	sendbuf[3]=0;      //卡座
	sendbuf[4]=0;

	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
		sendbuf[4]=sendbuf[4]^sendbuf[i];

	////Sleep(10);
    SendData_N(icdev,5,sendbuf);
    rt=RecData_N(icdev,&len,rebuf);
    if(rt!=0)
    {
    	return rt;	
    }
	samso[0]=rebuf[2];
	return 0;
}


DLLexport int WINAPI Buzzer(int n)
{
	return 1;
}





//125K类型ID卡，串口初始化,设置超时
DLLexport HANDLE WINAPI rf_init_125KCard(int icdev,long baud)
{
#if WIN32
   HANDLE h_dev;
   COMMTIMEOUTS CommTimeOuts;
   rf_PowerRFIDON();
   
   Sleep(100);

   h_dev=OpenComm(icdev,baud);
   if (h_dev==(HANDLE) -1)
   { 
	   rf_exit(h_dev);
	   return (HANDLE) -130;
   }
   GetCommTimeouts(h_dev,&CommTimeOuts);

   CommTimeOuts.ReadIntervalTimeout = 5;
   CommTimeOuts.ReadTotalTimeoutConstant =200;
   CommTimeOuts.WriteTotalTimeoutConstant =1000;
   CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
   SetCommTimeouts(h_dev,&CommTimeOuts);

   uchar t=0,rt=0;
  
 	
   PurgeComm(h_dev,PURGE_TXCLEAR);
   PurgeComm(h_dev,PURGE_RXCLEAR);

   DCB dcb;
   GetCommState(h_dev,&dcb);
   //dcb.BaudRate = baud;
   dcb.BaudRate = 115200;
   SetCommState(h_dev,&dcb);

   return h_dev;
#else
   	return 0;
#endif


}


//读取125卡中数据（“卡类型”后面的5个字节），数据以十六进制形式表示
//返回0正常，返回1失败
DLLexport int WINAPI rf_read_125Card_hex(HANDLE  icdev,uchar *_Data)
{
	uchar start=0;
	uchar rebuf[40];
	uchar len=0;
	int i=0;
	int j=0;

	j=ReadChar(icdev,&start);
	if(start==0x02&&j==1)
	{
  		if(ReadChar(icdev,&len)==0)
			return 1;
		for(i=0;i<=len-5;i++)				
		{
			if(ReadChar(icdev,&rebuf[i])==0)
				return 1;
		}
		for(i=0;i<5;i++)
		*(_Data+i)=rebuf[1+i];
		
		return 0;
	}
	return 1;
}

DLLexport int WINAPI barcode_trig(HANDLE  icdev,uchar ms)
{
    int i;
	uchar t=0,rt=0;
	uchar len=0;
	uchar LRC=0;
	uchar sendbuf[30];
	uchar rebuf[40];

	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02;   //数据长度
	sendbuf[2]=0x4E;   //得到当前卡座
	sendbuf[3]=ms;      //卡座
	sendbuf[4]=0;

	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	sendbuf[4]=sendbuf[4]^sendbuf[i];

	////Sleep(10);
	SendData_N(icdev,5,sendbuf);

	return 0;

}


DLLexport int WINAPI barcode_read(HANDLE  icdev,int ms,uchar *_Data)
{
	uchar start=0;
	uchar rebuf[40];
	uchar len=0;
	int i=0;
	int j=0;

	start=0;


	//开始处理超时
	while(1)
	{

		if(ReadChar(icdev,&_Data[start])==0)
		{
			if(ms>0)
			{
				ms--;
			}
			else
			{
				return start;		//超时退出
			}
		}
		else
		{
			start=start+1;
			break;
		}
	}

	while(1)
	{

		if(ReadChar(icdev,&_Data[start])==0)
		{
				return start;		//超时退出

		}
		else
		{
				start=start+1;
		}
	}
}


//读取当前CPU卡座位置(0~3)
DLLexport  int  WINAPI write_com(HANDLE icdev,uchar len,unsigned char *_Data )
{
    int i;
	uchar LRC=0;
	uchar sendbuf[300];
	uchar rebuf[40];

	PurgeComm(icdev,PURGE_TXCLEAR);
	PurgeComm(icdev,PURGE_RXCLEAR);
	sendbuf[0]=0xa7;   //起始符
	sendbuf[1]=0x02+len;   //数据长度
	sendbuf[2]=0x4d;   //得到当前卡座

	memcpy(&sendbuf[3],_Data,len);
	LRC=0;
	//求异或校验值
	for(i=0;i<2+sendbuf[1];i++)
	{
		LRC=LRC^sendbuf[i];
	}
	sendbuf[3+len]=LRC;

	////Sleep(10);
    SendData_N(icdev,3+len,sendbuf);

	return 0;
}

